#ifndef HOJA_H_
#define HOJA_H_
#include "Tipos.h"
#include "NodoBase.h"
//#include "Nodo.h"

typedef map<int,void*>				VectorClavesHoja;
typedef map<int,void*>::iterator	itVectorClavesHoja;
using namespace std;


template<class CClave>
class CHoja : public CNodoBase<CClave>
{
public:
	VectorClavesHoja	clave;
	TIPO_DATO			sigSetSec;	//nexo derecho del set secuencial	/*B+*/

	CHoja();
	CHoja(CHoja<CClave> &nodo);
	CHoja(TIPO_DATO nivel, TIPO_DATO nroBloque);
	virtual ~CHoja();
	
//	CHoja(CNodoBase<CClave> &nodo);
	//while(i<cantidadRegistro)
	//clave[i].transformar();
   	CClave &getClave(TIPO_DATO indice){return *((CClave*)clave[indice]);}
   	CClave* getspClave(TIPO_DATO indice){return ((CClave*)clave[indice]);}   	
   	
	CClaveNodo<CClave> &getClaveNodo(TIPO_DATO indice){CClaveNodo<CClave> *a=NULL; return *a;}
	CClaveNodo<CClave>* getspClaveNodo(TIPO_DATO indice){return NULL;}
	TIPO_DATO getSucesorIzq(){return 0;}
	TIPO_DATO getSucesorDer(int indice){return 0;}
	bool obtenerNroBloque(CClave &espacioLibre,TIPO_DATO &nroBloqueOut,fstream &archivo);

	TIPO_DATO getTamRegistro(TIPO_DATO indice){return ((CClave*)clave[indice])->getTamanio();}
	TIPO_DATO getSigSetSec(void){return this->sigSetSec;} /*B+*/
	TIPO_DATO getTamanio();
	TIPO_DATO getTamanio(int indice);

	void setSucesorIzq(TIPO_DATO suc){}
	void setSucesorDer(TIPO_DATO suc,TIPO_DATO indice){}
	void setSucesorDer(TIPO_DATO suc){}
	void setClave(CClave &key, TIPO_DATO posicion){this->clave[posicion] = &key;};
   	void setClave(CClave &clave){this->clave[this->cantRegistro-1]=(((void*)(&clave)));}
	void setSigSetSec(TIPO_DATO blqSig){this->sigSetSec = blqSig;}/*B+*/

	bool equilibrarConHrno(TIPO_DATO indice);
 	void clear(){this->clave.clear(); this->setCantRegistros(0);}
	void distribuirClaves( TIPO_DATO &sucesorIzq, TIPO_DATO &sucesorDer,CClave &clave,CHoja<CClave> &nodoNuevo);   	
	void eliminar(CClave &clave);
	void eliminar(TIPO_DATO indice);
	void fusionar(CNodoBase<CClave> &nodoPadre,TIPO_DATO posPadre,CNodoBase<CClave> &nodoHrno);
	void procesarHoja(void);
	void transformar(string datos);
	string desTransformar();
    void insertarOrdenado(CClave& clave,TIPO_DATO nroBloqueViejo,TIPO_DATO nroBloqueNuevo);

	void mostrar();
	bool haySigSetSec(void){return this->sigSetSec != FIN_SET_SECUENCIAL;}
	bool hayLugar(CClave &claveIn){
		return (this->espacioLibre >= claveIn.getTamanio());}
	/*ordeno el mapa que tiene la clase que lo usa.*/
	void ordenar();
	void insertarVectorSec(CClave &clave,fstream &archivo);
	bool cambiarClave(CClave &claveVieja,CClave &claveNueva);
	bool eliminarElemVector(TIPO_DATO claveIn,fstream &archivo);	
	bool puedoFusionar(TIPO_DATO tamHermano,TIPO_DATO tamClave);
	void intercambiar(CNodoBase<CClave> &nodoHrno,bool hrnoDerecho,CNodoBase<CClave> &nodoPadre,TIPO_DATO posPadre);
};
/*-----------------------------------------------------------*/
template<class CClave>
CHoja<CClave>::CHoja()
{
	this->nroNodoBloque=0; //referencia al bloque de indice
	this->cantRegistro=0;
	this->nivel=0;		
	this->posicion=0;//posicion donde encontro
	this->m_posicionTrans=0;//posicion que se usa para el trasformar.	
	this->totalByte=0;//este atributo lo carga MARCO despues de trasformar todo	
	this->sigSetSec			= FIN_SET_SECUENCIAL;/*B+*/	
	this->clave.clear();
}
/*-----------------------------------------------------------*/
template<class CClave>
CHoja<CClave>::CHoja(CHoja<CClave> &nodo)
{
	TIPO_DATO cantReg;
	CClave* nodoAux;
	if(this!=&nodo)
	{
		
//		cantReg = ((CHoja<CClave>)nodo).getCantRegistros();
		cantReg = nodo.getCantRegistros();
		this->espacioLibre = nodo.getEspacioLibre();
		this->sigSetSec		= nodo->sigSetSec;	/*B+*/
		TIPO_DATO i=0; 
		for(;i<cantReg;i++)
		{
			nodoAux = new CClave;
			nodoAux = ((CHoja<CClave >)nodo).getspClave(i);
			this->setClave(*nodoAux,i);
		}
	}
}
/*-----------------------------------------------------------*/
/*
template<class CClave>
CHoja<CClave>::CHoja(CNodoBase<CClave> &nodo)
{
	TIPO_DATO cantReg;
	CClave* nodoAux;
	cantReg = ((CHoja<CClave>)nodo).getCantRegistros();
	for(TIPO_DATO i=0;i<cantReg;i++)
	{
		nodoAux = new CClave;
		nodoAux = ((CHoja<CClave>)nodo).getspClave(i);
		this->setClave(*nodoAux);
	}
}
*/
template<class CClave>
CHoja<CClave>::CHoja(TIPO_DATO nivel, TIPO_DATO nroBloque)
{
	this->nivel =nivel ;
	this->nroNodoBloque = nroBloque;
	this->sigSetSec = FIN_SET_SECUENCIAL;/*B+*/

}
template<class CClave>
CHoja<CClave>::~CHoja()
{
	itVectorClavesHoja it;	
	for(it = this->clave.begin();it != this->clave.end();it++)
	{
		delete((CClave*)(*it).second);
	//	clave.erase(it);
	}
	clave.clear();
}
/*-----------------------------------------------------------*/
template <class CClave >
void CHoja<CClave>::eliminar(CClave &clave)
{
	/*
	itVectorClavesHoja it;
	it = this->clave.find(indice);
	if(it!=clave.end())
	{
		this->clave.erase(it);
		this->cantRegistro--;
	}
	*/
	
	
	bool encontrada=false;
	itVectorClavesHoja it;
	it = this->clave.begin();
	while((it != this->clave.end()) && !encontrada)
	{
		if(clave==(*it))
		{
			encontrada=true;
			this->clave.erase(it);
			this->cantRegistro--;
			for(TIPO_DATO i=(*it).first;i<=this->cantRegistro;i++)
				clave[i]=clave[i+1];

		}		
		++it;
	}

}
/*-----------------------------------------------------------*/
template <class CClave >
void CHoja<CClave>::mostrar() /* = std::cout*/
{
	itVectorClavesHoja it;
	cout<<endl<<"\tNumero de bloque Indice: "<<this->nroNodoBloque<<endl;
	cout<<" Nivel del nodo : "<<this->nivel<<endl;
	cout<<" Siguiente :"<<this->sigSetSec<<endl;
	
	for(it=clave.begin();it!=clave.end();it++)
			((CClave*)(*it).second)->mostrar();

}
/*-----------------------------------------------------------*/
template <class CClave >
void CHoja<CClave>::eliminar(TIPO_DATO indice)
{
	//TIPO_DATO index=0;
	itVectorClavesHoja it;

	it = this->clave.find(indice);
	if(it!=this->clave.end())
	{
		TIPO_DATO i;
//VERRRR		delete ((it)->second);
		this->espacioLibre += ((CClave*)((*it).second))->getTamanio();
		this->clave.erase(it);
		this->cantRegistro--;
		for(i=indice;i<this->cantRegistro;i++)
			clave[i]=clave[i+1];
		this->clave.erase(i);
	}

	it = this->clave.begin();
	while((it != this->clave.end()) )
	{
		((CClave*)(*it).second)->mostrar();
		++it;
	}

	/*
	bool encontrada=false;
	
	it = this->clave.begin();
	while((it != this->clave.end()) && !encontrada)
	{
		if(index==indice)//(clave==(*it))
		{
			encontrada=true;
			this->clave.erase(it);
			this->cantRegistro--;
		}		
		++it;
		++index;
	}
	}
	*/
}
/*-----------------------------------------------------------*/
template <class CClave >
void CHoja<CClave>::insertarOrdenado(CClave& key,TIPO_DATO nroBloqueViejo,TIPO_DATO nroBloqueNuevo)
{
	TIPO_DATO i=0;
	CClave	*claveAux;
	VectorClavesHoja	vecClaveAux;	

	for(i=0; (i < this->cantRegistro) && (*(claveAux =this->getspClave(i))) < key ; i++)
		vecClaveAux[i]=(claveAux);

	vecClaveAux[i]=(&key);
	this->posicion =i;
	this->espacioLibre-=key.getTamanio();
	for(;i<this->cantRegistro;i++)
	{
		claveAux =this->getspClave(i);
		vecClaveAux[i+1]=(claveAux);
	}
	for(i=0;i<=this->cantRegistro;i++)
		this->clave[i]=((CClave*)vecClaveAux[i]);
	++this->cantRegistro;
}
/*-----------------------------------------------------------*/
/*informa si puedo sacar un registro de este nodo sin que quede en underflow*/
template<class CClave>
bool CHoja<CClave>::equilibrarConHrno(TIPO_DATO indice)
{
	TIPO_DATO	tamRegByte;
	TIPO_DATO  	porcentaje;
	//tengo el tamanio del ultimo registro
	tamRegByte = this->getTamRegistro(indice);
	porcentaje = (TIPO_DATO)(((double)(this->espacioLibre + tamRegByte )/TAMANIO_NODO)*100);
	if(porcentaje > PORCENTAJE_MINIMO)
		return false;
	return true;	
}
/*-----------------------------------------------------------*/
/*
	posNodoviejo: numero de bloque viejo
	posNodoNuevo: numero de bloque Nuevo
*/
template <class CClave >
void CHoja<CClave>::distribuirClaves(TIPO_DATO &sucesorIzq, TIPO_DATO &sucesorDer,CClave &key,CHoja<CClave> &nodoNuevo)
{
     /* metodo para HOJA */
     //creo un superNodo conteniendo el nodo viejo mas la clave nueva insertada
     //en el lugar correcto
     VectorClavesHoja	SuperNodo;
     TIPO_DATO corte, cantRegSuperNodo;   
     TIPO_DATO i=0;
     CClave *claveAux, *promociona;
     promociona = new CClave;
	/*Inserta la nueva clave en un supernodo de forma ordenada*/
	for(i=0; (i<this->cantRegistro) && (*(claveAux = this->getspClave(i))) < key ; i++)
		SuperNodo[i] = (claveAux);
	*promociona = key;
	SuperNodo[i] = (promociona);
//	if(i==0)
//		++i;
	for(; i<this->cantRegistro; i++)
	{
		claveAux = this->getspClave(i);
		SuperNodo[i+1] = (claveAux);
	}
/**/ 	
     //aca el super nodo contine todas las claves ordenadas
     //ahora armo los nodos viejo(izq) y nuevo(der) obteniendo la clave a promocionar
     cantRegSuperNodo = ++i;
     cout<<"Contenido del SUPERNODO al insertar(Distribuir claves HOJA)"<<endl;
//     for(int h=0; h<(int)cantRegSuperNodo ; h++)
//	     ((CClave*)SuperNodo[h])->mostrar();	     
	     
     corte = (i/2); /*TODO con claves variables ver como obtiene el corte*/
     TIPO_DATO j;     
     this->clear(); //limpio el vector de claves 
     cout<<"Contenido del nodo (IZQ) luego de distribuir el supernodo"<<endl;     
     for(j=0; j<corte; j++ )   
     {  
	 	this->setClave(*((CClave*)SuperNodo[j]),j);
//	 	this->getClave(j).mostrar();
     }     
     //SETEAR LA CANTIDAD DE REGISTROS
     this->cantRegistro = j;
	 	
	 //esta clave es la que promociona
     key = *((CClave*)SuperNodo[j]);
   //  delete ((CClave*)SuperNodo[j-1]);
  	 sucesorIzq = this->nroNodoBloque; //esta hoja es el bloque viejo osea sucesor Izq
     sucesorDer = nodoNuevo.getNroBloque();
  //  ((CNodo<CClave>*)m_rama)[posNodoNuevo]->setSucesorDer(nroBloqueNuevo,);

     nodoNuevo.clear();
     cout<<"Contenido del nodo (DER) luego de distribuir el supernodo"<<endl;
     for(; j<(cantRegSuperNodo); j++)
     {
     	claveAux = ((CClave*)SuperNodo[j]);
     	nodoNuevo.setClave(*(claveAux),j-corte); 
//     	nodoNuevo.getClave(j-corte).mostrar();     	
	 	//nodoNuevo.setClave(*((CClave*)SuperNodo[j]),j-corte-1);
     }
     
/*VER 'key' DEBE tener la DIRECCION del puntero 'promociona'*/
/**/ //(&key) = promociona; //Sino usa esta auxiliar se pisa el valor a promocionar.
/**/    
    
    //SETEAR LA CANTIDAD DE REGISTROS      
	nodoNuevo.setCantRegistros(j-corte);  
}
/*-----------------------------------------------------------*/
/*this: el nodo que tiene la clave a eliminar*/
/*el padre siempre va a ser un nodo*/
template <class CClave >
void CHoja<CClave>::fusionar(CNodoBase<CClave> &nodoPadre,TIPO_DATO posPadre,CNodoBase<CClave> &nodoHrno)
{
	TIPO_DATO cantReg;//, aux;
	TIPO_DATO sucDerPadre;
	bool entro=false;/*jny*/
	CClave *spClaveAux=NULL;
/*BMas	CClaveNodo<CClave> *spClavePadre=new CClaveNodo<CClave>;*/
	TIPO_DATO i=0;
	/*pasamos el vector del hermano al vector this*/
	cantReg = nodoHrno.getCantRegistros();
	while(i<cantReg)
	{
		spClaveAux= new CClave;
		spClaveAux = nodoHrno.getspClave(i++);
		/*jny*/	this->espacioLibre -= spClaveAux->getTamanio();		
		this->cantRegistro++;
		this->setClave(*spClaveAux);		
	}
	/*TODO MANEJAR EL ARCHIVO DE ESPACIOS LIBRES*/
//	nodoHrno.clear();//borramos el nodo hermano
	nodoHrno.setCantRegistros(0);
	//aux = nodoPadre.getCantRegistros();
	//(*spClavePadre) = nodoPadre.getClaveNodo(posPadre);
	sucDerPadre = nodoPadre.getSucesorDer(posPadre);
	//this->cantRegistro++;
	//this->setClave(spClavePadre->clave);	
/********************///	sort(clave.begin(),clave.end());
	ordenar();
	/*Actualizo el siguiente*/
	if(this->nroNodoBloque != nodoHrno.getSigSetSec())
		this->sigSetSec = nodoHrno.getSigSetSec();
	else
	{
		/*si el que se elimina es el hrno que esta entre medio de los nodos antiguos y el nodo this */
		if(posPadre!=0)	
		{
			TIPO_DATO nroBloqueAux;
			nroBloqueAux = this->nroNodoBloque;
			this->nroNodoBloque = nodoHrno.getNroBloque();
			nodoHrno.setNroBloque(nroBloqueAux);
		}
	}

	/*ACTUALIZO EL NODO PADRE*/
	if(this->nroNodoBloque==sucDerPadre)	
		if(posPadre==0)	
		{
			nodoPadre.setSucesorIzq(nodoHrno.getNroBloque());		
			entro=true;/*jny*/
		}
		else		
			nodoPadre.setSucesorDer(this->nroNodoBloque,posPadre-1);
	nodoPadre.eliminar(posPadre);
	if(nodoPadre.getCantRegistros()==0 && (nodoPadre.getSucesorIzq()!=this->nroNodoBloque) && !entro/*jny*/)
		nodoPadre.setSucesorIzq(-1);


	itVectorClavesHoja it;
		for(it=clave.begin();it!=clave.end();it++)
		((CClave*)((*it).second))->mostrar();
}/*-----------------------------------------------------------*/
template <class CClave >
void CHoja<CClave>::transformar(string datos)
{
	//TIPO_DATO pos = this->m_posicionTrans;
	TIPO_DATO pos = 0;
	TIPO_DATO tamanioDatos=0;//este es el tama�o de datos en byte que se esta acumulando.
	CNodoBase<CClave>::transformar(datos,pos);	
	this->sigSetSec = string2TipoDato(datos.substr(pos,TAMANIO_NRO_BLOQ));
	pos+=TAMANIO_NRO_BLOQ;
	this->espacioLibre -=TAMANIO_NRO_BLOQ;
	 	 //transformar los datos en clave
	if(this->nivel!=0)
		cout<<"El nivel es distinto de cero NO ESTA BIEN!!!"<<endl;
	for(TIPO_DATO i=0; i<this->cantRegistro; i++)
	{
		CClave *key= new CClave;
	 	//Parseo la clave
	 	tamanioDatos += key->transformar(datos, pos);
	 	this->clave[i]=(key);
	}
		/*
		 * TAMANIO_NODO : tamanio del nodo total.
		 * sizeof(TIPO_DATO)*3 : datos administrativos
		 * tamanioDatos : datos cargados
		 * */ 	 
	this->espacioLibre -= tamanioDatos ;
}
/*-----------------------------------------------------------*/
template <class CClave >
string CHoja<CClave>::desTransformar()
{
	CClave key;
	itVectorClavesHoja it;
	string dato="";
	dato += CNodoBase<CClave>::desTransformar();
	dato += convertirChar(this->sigSetSec,TAMANIO_NRO_BLOQ);
	for(it=clave.begin();it!=clave.end();it++)
	//for(TIPO_DATO i=0; i<this->cantRegistro; i++)
	{
		key =getClave((*it).first);
		dato+=key.desTransformar();
	}
	return dato;
}
/*-----------------------------------------------------------*/
/*cuando entro aca ya se que el que se va a partir es la raiz*/
/*cuando trabajo con este metodo supongo que el this es la raiz antigua*/
/*template <class CClave >
void CHoja<CClave>::redistribuirRaiz(TIPO_DATO nivel,CClave &clave,TIPO_DATO nroBloqueViejo,TIPO_DATO nroBloqueNuevo,CNodoBase<CClave> &raizAntigua)
{
	CClave claveAux;
	for(int i=0;i<this->cantRegistro;i++)
	{
		claveAux=((CNodo<CClave>)raizAntigua)->getClave(i);
		//aca le estoy pasando al nuevo bloque creado
	 	setClave(claveAux);		
	}
	//vuelvo a cargar la El primer BLOQUE con la nueva raiz 
	// en este caso esta raiz tiene la clave promovida.
	//como es una hoja no tiene sucesores	 	
    ((CNodo<CClave>)raizAntigua)->clear();
	((CNodo<CClave>)raizAntigua)->setClave(clave,0);	
 	((CNodo<CClave>)raizAntigua)->setCantRegistros(1);
	
}
*/
/*-----------------------------------------------------------*/
template <class CClave >
void CHoja<CClave>::procesarHoja(void)
{
	CClave clave;
	TIPO_DATO_CHICO cantReg, i=0;
	cantReg = this->getCantRegistros();
	while ( i < cantReg )
	{
		clave = this->getClave(i);		
		/*TODO ver que proceso se le da a esta clave*/
		clave.mostrar();
	}	
}

template <class CClave >
void CHoja<CClave>::ordenar(void)
{
	int						posicion=0;
	VectorClavesHoja		vectorClaves;
	itVectorClavesHoja		it;
	for(it=clave.begin();it!=clave.end();it++)
		((CClave*)((*it).second))->mostrar();

	for(it=clave.begin();it!=clave.end();it++,posicion++)
	{
		int cont=posicion;
		//vectorClaves.insert(*it);
		while((posicion!=0) && cont>0 &&(*((CClave*)((*it).second)))<(*((CClave*)vectorClaves[cont-1])))
		{
			vectorClaves[cont] = vectorClaves[cont-1];
			--cont;
		}
		vectorClaves[cont]=(*it).second;
	}
	clave.clear();	
	for(it=vectorClaves.begin();it!=vectorClaves.end();it++)
		clave.insert((*it));
	vectorClaves.clear();
	/*mustro como quedo*/
	for(it=clave.begin();it!=clave.end();it++)
		((CClave*)((*it).second))->mostrar();
}

template<class CClave>
void CHoja<CClave>::insertarVectorSec(CClave &claveIn,fstream &archivo)
{
	CClave *prueba= new CClave;
	prueba = ((CClave*)clave[this->posicion]);
	//TIPO_DATO codProdIn,TIPO_DATO nrobloque,fstream &archivo
	((CClave*)clave[this->posicion])->insertarVectorSec(((CClave*)&claveIn)->getCodProducto(0),archivo);
}
template <class CClave >
bool CHoja<CClave>::cambiarClave(CClave &claveVieja,CClave &claveNueva)
{
	if((*((CClave*)(this->clave[this->posicion])))==claveVieja)
	{
		this->clave[this->posicion]=&claveNueva;
		return true;
	}
	else
		cout<<"TENDRIA QUE SER IGUAL!!!!!!!!!!!!!!"<<endl;
	return false;
}


template <class CClave >
bool CHoja<CClave>::obtenerNroBloque(CClave &espacioLibre,TIPO_DATO &nroBloqueOut,fstream &archivo)
{
	bool encontrado =false;
	CClave espacioAux;
	TIPO_DATO i;
	for(i=0;i<this->cantRegistro && !encontrado;i++)
	{
		espacioAux = (*((CClave*)(this->clave[i])));
		if((*((CClave*)(this->clave[i])))==espacioLibre)
			encontrado =true;
	}
	if(encontrado)
		encontrado=((CClave*)this->clave[i-1])->obtenerNroBloque(nroBloqueOut,archivo);
	else
		cout<<"Tendria que haberlo encontrado"<<endl;
	return encontrado;
}
template <class CClave >
bool CHoja<CClave>::eliminarElemVector(TIPO_DATO claveIn,fstream &archivo)
{
	bool eliminado;
	this->m_eliminar =false;
	eliminado = ((CClave*)this->clave[this->posicion])->eliminarElemVector(claveIn,archivo);
	if(((CClave*)this->clave[this->posicion])->getIndice()==0)
		//this->eliminar(this->posicion);
		this->m_eliminar=true;
	return eliminado;
}

template<class CClave>
TIPO_DATO CHoja<CClave>::getTamanio()
{
	TIPO_DATO tamanio=0;
	itVectorClavesHoja it;
	tamanio = TAMANIO_CANTIDAD_REGISTRO +TAMANIO_NIVEL;
	for(it=this->clave.begin();it!=this->clave.end();it++)
		tamanio+=((CClave*)((*it).second))->getTamanio();
	return tamanio;
}
template<class CClave>
TIPO_DATO CHoja<CClave>::getTamanio(int indice)
{	
	return ((CClave*)this->clave[indice])->getTamanio();
	//return tamanio;
}
template<class CClave>
bool CHoja<CClave>::puedoFusionar(TIPO_DATO tamHermano,TIPO_DATO tamClave)
{
	//return  ((getTamanio() + tamHermano)<= TAMANIO_NODO)? true:false;
	if((getTamanio() + tamHermano)<= TAMANIO_NODO)
		return true;
	return false;
}

template<class CClave>
void CHoja<CClave>::intercambiar(CNodoBase<CClave> &nodoHrno,bool hrnoDerecho,CNodoBase<CClave> &nodoPadre,TIPO_DATO posPadre)

{
	CClave *spClaveHrno=NULL;/*BMas,*spClavePadre=NULL;*/
	TIPO_DATO cantRegistros,sucDerHrno,indice;
	spClaveHrno = new CClave;
	//spClavePadre =new CClave;
	//ESTE IF ESTA MAL VER COMO DIFERENCIO SI AGARRO EL HRNO DERECHO O EL IZQUIERDO
//	

	if(hrnoDerecho)//el hrno que le va a prestar es el derecho
		indice = 0;
	else
		indice = cantRegistros = (*((CHoja<CClave>*)&nodoHrno)).getCantRegistros() -1;

	/**obtengo la clave del hermano*/
	spClaveHrno =(*((CHoja<CClave>*)&nodoHrno)).getspClave(indice);
	sucDerHrno = (*((CHoja<CClave>*)&nodoHrno)).getSucesorDer(indice);
	(*((CHoja<CClave>*)&nodoHrno)).eliminar(indice);	
	
	++this->cantRegistro;
//	cantRegistros = ((CNodoBase<CClave>*)m_rama[posRama-0])->getCantRegistros();
//	((CNodoBase<CClave>*)m_rama[posRama-0])->setCantRegistros(cantRegistros +1);
	//pos = ((CNodoBase<CClave>*)m_rama[posRama -0])->getPosicion();		
	this->setClave(*spClaveHrno);	

	
	
	this->ordenar();//despues de ordenar queda en la posicion=0 o al final
	//((CNodoBase<CClave>*)m_rama[posRama-0])->setPosicion(pos);
	this->mostrar();
	
	if(hrnoDerecho)
		spClaveHrno =(*((CHoja<CClave>*)&nodoHrno)).getspClave(indice);
	(*((CNodo<CClave>*)&nodoPadre)).setClave(*spClaveHrno,posPadre);

}

#endif /*HOJA_H_*/

